/**
 * API服务工具
 * 处理与后端API的通信
 */

import axios from 'axios';

// API基础URL
const API_BASE_URL = 'http://localhost:5000/api';
const CTCLIP_API_URL = 'http://localhost:5001/api';

// 创建axios实例
const apiClient = axios.create({
  baseURL: API_BASE_URL,
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
});

// NIfTI相关API
export const niftiApi = {
  /**
   * 将NIfTI文件分割为多个2D切片
   * @param file NIfTI文件(.nii或.nii.gz)
   * @param options 分割选项
   * @returns 处理结果
   */
  splitNifti: async (file: File, options: {
    orientation?: string;
    normalize?: boolean;
    enhance?: boolean;
    format?: string;
  } = {}) => {
    try {
      const formData = new FormData();
      formData.append('file', file);
      
      // 添加可选参数
      if (options.orientation) {
        formData.append('orientation', options.orientation);
      }
      
      if (options.normalize !== undefined) {
        formData.append('normalize', options.normalize ? 'true' : 'false');
      }
      
      if (options.enhance !== undefined) {
        formData.append('enhance', options.enhance ? 'true' : 'false');
      }
      
      if (options.format) {
        formData.append('format', options.format);
      }
      
      const response = await fetch(`${API_BASE_URL}/nifti/split`, {
        method: 'POST',
        body: formData
      });
      
      if (!response.ok) {
        // 处理非200响应
        const errorData = await response.json();
        throw new Error(errorData.message || '服务器错误');
      }
      
      return await response.json();
    } catch (error) {
      console.error('NIfTI分割失败:', error);
      throw error;
    }
  }
};

// 图像分割相关API
export const segmentationApi = {
  /**
   * 使用VM-UNet模型对上传的医疗图像进行分割
   * @param file 要上传的图像文件(支持png, jpg, jpeg)
   * @param threshold 分割阈值，默认值0.5
   * @returns 包含分割结果图像路径的对象
   */
  segmentImage: async (file: File, threshold: number = 0.5) => {
    try {
      console.log(`开始分割图像: ${file.name}, 大小: ${file.size}, 类型: ${file.type}, 阈值: ${threshold}`);
      
      const formData = new FormData();
      formData.append('file', file);
      formData.append('threshold', threshold.toString());
      
      console.log('准备发送分割请求到:', `${API_BASE_URL}/segment`);
      const response = await fetch(`${API_BASE_URL}/segment`, {
        method: 'POST',
        body: formData
      });
      
      if (!response.ok) {
        // 处理非200响应
        const errorText = await response.text();
        let errorData;
        try {
          errorData = JSON.parse(errorText);
        } catch (e) {
          errorData = { error: errorText };
        }
        console.error('分割API返回错误:', response.status, errorData);
        throw new Error(errorData.error || `服务器错误: ${response.status}`);
      }
      
      const result = await response.json();
      console.log('分割成功，结果:', result);
      return result;
    } catch (error) {
      console.error('图像分割失败:', error);
      throw error;
    }
  }
};

// CTClip相关API
export const ctClipApi = {
  /**
   * 使用CTClip模型对CT图像生成文本描述
   * @param file 要上传的CT图像文件(支持jpg, jpeg, png)
   * @returns 包含预测文本及概率的对象
   */
  predictDescription: async (file: File) => {
    try {
      const formData = new FormData();
      formData.append('file', file);
      
      const response = await fetch(`${CTCLIP_API_URL}/predict`, {
        method: 'POST',
        body: formData
      });
      
      if (!response.ok) {
        // 处理非200响应
        const errorData = await response.json();
        throw new Error(errorData.error || '服务器错误');
      }
      
      return await response.json();
    } catch (error) {
      console.error('CTClip预测失败:', error);
      throw error;
    }
  }
};

// 诊断报告生成相关API
export const diagnosisApi = {
  /**
   * 生成诊断报告
   * @param imageDescription CT图像描述（来自CTClip模型的预测结果）
   * @param electronicRecord 电子病历记录
   * @returns 包含生成的诊断报告内容
   */
  generateDiagnosisReport: async (imageDescription: string, electronicRecord: any) => {
    try {
      const response = await fetch(`${CTCLIP_API_URL}/diagnosis`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          image_description: imageDescription,
          electronic_record: electronicRecord
        })
      });
      
      if (!response.ok) {
        // 处理非200响应
        const errorData = await response.json();
        throw new Error(errorData.error || '服务器错误');
      }
      
      return await response.json();
    } catch (error) {
      console.error('诊断报告生成失败:', error);
      throw error;
    }
  }
};

// 图像相关API
export const imageApi = {
  /**
   * 获取所有分割结果图像
   * @param type 过滤特定类型的结果图像，可选值: 'mask', 'prob', 'vis', 'overlay'
   * @param limit 限制返回的结果数量
   * @returns 分割结果图像列表
   */
  getResults: async (type?: string, limit?: number) => {
    try {
      let url = '/results';
      const params = new URLSearchParams();
      
      if (type) {
        params.append('type', type);
      }
      
      if (limit) {
        params.append('limit', limit.toString());
      }
      
      const queryString = params.toString();
      if (queryString) {
        url += `?${queryString}`;
      }
      
      const response = await apiClient.get(url);
      return response.data;
    } catch (error) {
      console.error('获取分割结果失败:', error);
      throw error;
    }
  },

  /**
   * 获取图像列表
   * @param path 图像路径，默认为/static/results
   * @returns 图像列表
   */
  getImages: async (path = '/static/results') => {
    try {
      const response = await apiClient.get(`/api/images${path}`);
      return response.data;
    } catch (error) {
      console.error('获取图像列表失败:', error);
      throw error;
    }
  },

  /**
   * 获取目录中的所有文件
   * @param directoryPath 目录路径，如/static/results
   * @returns 文件列表
   */
  getDirectoryFiles: async (directoryPath: string) => {
    try {
      // 实际项目中应该有一个API端点来获取目录文件列表
      // 这里我们模拟直接访问目录
      const response = await apiClient.get(`/api/files?directory=${directoryPath}`);
      return response.data;
    } catch (error) {
      console.error('获取目录文件列表失败:', error);
      
      // 如果后端没有提供获取文件列表的API，我们可以尝试模拟一个文件列表
      // 这只是一个临时解决方案，实际项目中应该由后端提供API
      if (directoryPath.includes('results')) {
        return [
          '07a4d770-361d-4bba-9bba-f741ab67d0a6_mask.png',
          '07a4d770-361d-4bba-9bba-f741ab67d0a6_overlay.png',
          '07a4d770-361d-4bba-9bba-f741ab67d0a6_prob.png',
          '07a4d770-361d-4bba-9bba-f741ab67d0a6_vis.png',
          '8f298d92-002d-4cf0-9acf-f89557d4e0b5_mask.png',
          '8f298d92-002d-4cf0-9acf-f89557d4e0b5_overlay.png',
          '8f298d92-002d-4cf0-9acf-f89557d4e0b5_prob.png',
          '8f298d92-002d-4cf0-9acf-f89557d4e0b5_vis.png',
          'db437095-d158-4d6e-81fc-44517ca5101c_mask.png',
          'db437095-d158-4d6e-81fc-44517ca5101c_overlay.png',
          'db437095-d158-4d6e-81fc-44517ca5101c_prob.png',
          'db437095-d158-4d6e-81fc-44517ca5101c_vis.png',
          'f2ca956e-aee8-4ead-84d5-48d4785f4333_mask.png'
        ];
      }
      
      return [];
    }
  },

  /**
   * 获取单个图像
   * @param filename 图像文件名
   * @returns 图像数据
   */
  getImage: async (filename: string) => {
    try {
      const response = await apiClient.get(`/static/uploads/${filename}`);
      return response.data;
    } catch (error) {
      console.error('获取图像失败:', error);
      throw error;
    }
  },

  /**
   * 获取图像URL
   * @param filename 图像文件名
   * @returns 图像URL
   */
  getImageUrl: (filename: string) => {
    return `${API_BASE_URL}/static/uploads/${filename}`;
  },

  /**
   * 获取结果图像URL
   * @param filename 图像文件名
   * @returns 结果图像URL
   */
  getResultImageUrl: (filename: string) => {
    return `${API_BASE_URL}/static/results/${filename}`;
  }
};

export default {
  imageApi
};

// 可以在此处添加其他API模块
// export const someOtherApi = { ... }; 